{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# default_exp callback.PredictionDynamics"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# PredictionDynamics\n",
    "\n",
    "> Callback used to visualize model predictions during training. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This is an implementation created by Ignacio Oguiza (timeseriesAI@gmail.com) based on a [blog post](http://localhost:8888/?token=83bca9180c34e1c8991886445942499ee8c1e003bc0491d0) by Andrej Karpathy I read some time ago that I really liked. One of the things he mentioned was this: \n",
    ">\"**visualize prediction dynamics**. I like to visualize model predictions on a fixed test batch during the course of training. The “dynamics” of how these predictions move will give you incredibly good intuition for how the training progresses. Many times it is possible to feel the network “struggle” to fit your data if it wiggles too much in some way, revealing instabilities. Very low or very high learning rates are also easily noticeable in the amount of jitter.\" A. Karpathy\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#export\n",
    "from fastai.callback.all import *\n",
    "from tsai.imports import *"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# export\n",
    "class PredictionDynamics(Callback):\n",
    "    order, run_valid = 65, True\n",
    "\n",
    "    def __init__(self, show_perc=1., figsize=(6, 6), alpha=.3, size=30, color='lime', cmap='gist_rainbow'):\n",
    "\n",
    "        \"\"\"\n",
    "        Args:\n",
    "            show_perc:  percent of samples from the valid set that will be displayed. Default: 1 (all).\n",
    "                        You can reduce it if the number is too high and the chart is too busy.\n",
    "            alpha:      level of transparency. Default:.3. 1 means no transparency.\n",
    "            figsize:    size of the chart. You may want to expand it if too many classes.\n",
    "            size:       size of each sample in the chart. Default:30. You may need to decrease it a bit if too many classes/ samples.\n",
    "            color:      color used in regression plots.\n",
    "            cmap:       color map used in classification plots.\n",
    "\n",
    "        The red line in classification tasks indicate the average probability of true class.\n",
    "        \"\"\"\n",
    "\n",
    "        store_attr(\"show_perc,figsize,alpha,size,color,cmap\")\n",
    "\n",
    "    def before_fit(self):\n",
    "        self.run = not hasattr(self.learn, 'lr_finder') and not hasattr(self, \"gather_preds\")\n",
    "        if not self.run:\n",
    "            return\n",
    "        self.cat = True if (hasattr(self.dls, \"c\") and self.dls.c > 1) else False\n",
    "        if self.show_perc != 1:\n",
    "            valid_size = len(self.dls.valid.dataset)\n",
    "            self.show_idxs = np.random.choice(valid_size, int(round(self.show_perc * valid_size)), replace=False)\n",
    "\n",
    "        # Prepare ground truth container\n",
    "        self.y_true = []\n",
    "\n",
    "    def before_epoch(self):\n",
    "        # Prepare empty pred container in every epoch\n",
    "        self.y_pred = []\n",
    "\n",
    "    def after_pred(self):\n",
    "        if self.training:\n",
    "            return\n",
    "\n",
    "        # Get y_true in epoch 0\n",
    "        if self.epoch == 0:\n",
    "            self.y_true.extend(self.y.cpu().flatten().numpy())\n",
    "\n",
    "        # Gather y_pred for every batch\n",
    "        if self.cat:\n",
    "            y_pred = torch.gather(F.softmax(self.pred.detach().cpu(), 1), -1, self.y.cpu().reshape(-1, 1).long())\n",
    "        else:\n",
    "            y_pred = self.pred.detach().cpu()\n",
    "        self.y_pred.extend(y_pred.flatten().numpy())\n",
    "\n",
    "    def after_epoch(self):\n",
    "        # Ground truth\n",
    "        if self.epoch == 0:\n",
    "            self.y_true = np.array(self.y_true)\n",
    "            if self.show_perc != 1:\n",
    "                self.y_true = self.y_true[self.show_idxs]\n",
    "            self.y_bounds = (np.min(self.y_true), np.max(self.y_true))\n",
    "            self.min_x_bounds, self.max_x_bounds = np.min(self.y_true), np.max(self.y_true)\n",
    "\n",
    "        self.y_pred = np.array(self.y_pred)\n",
    "        if self.show_perc != 1:\n",
    "            self.y_pred = self.y_pred[self.show_idxs]\n",
    "        if self.cat:\n",
    "            self.update_graph(self.y_pred, self.y_true)\n",
    "        else:\n",
    "            # Adjust bounds during validation\n",
    "            self.min_x_bounds = min(self.min_x_bounds, np.min(self.y_pred))\n",
    "            self.max_x_bounds = max(self.max_x_bounds, np.max(self.y_pred))\n",
    "            x_bounds = (self.min_x_bounds, self.max_x_bounds)\n",
    "            self.update_graph(self.y_pred, self.y_true, x_bounds=x_bounds, y_bounds=self.y_bounds)\n",
    "\n",
    "    def after_fit(self):\n",
    "        plt.close(self.graph_ax.figure)\n",
    "\n",
    "    def update_graph(self, y_pred, y_true, x_bounds=None, y_bounds=None):\n",
    "        if not hasattr(self, 'graph_fig'):\n",
    "            self.df_out = display(\"\", display_id=True)\n",
    "            if self.cat:\n",
    "                self._cl_names = self.dls.vocab\n",
    "                self._classes = L(self.dls.vocab.o2i.values())\n",
    "                self._n_classes = len(self._classes)\n",
    "                self._h_vals = np.linspace(-.5, self._n_classes - .5, self._n_classes + 1)[::-1]\n",
    "                _cm = plt.get_cmap(self.cmap)\n",
    "                self._color = [_cm(1. * c/self._n_classes) for c in range(1, self._n_classes + 1)][::-1]\n",
    "                self._rand = []\n",
    "                for i, c in enumerate(self._classes):\n",
    "                    self._rand.append(.5 * (np.random.rand(np.sum(y_true == c)) - .5))\n",
    "            self.graph_fig, self.graph_ax = plt.subplots(1, figsize=self.figsize)\n",
    "            self.graph_out = display(\"\", display_id=True)\n",
    "        self.graph_ax.clear()\n",
    "        if self.cat:\n",
    "            for i, c in enumerate(self._classes):\n",
    "                self.graph_ax.scatter(y_pred[y_true == c], y_true[y_true == c] + self._rand[i],  color=self._color[i],\n",
    "                                      edgecolor='black', alpha=self.alpha, linewidth=.5, s=self.size)\n",
    "                self.graph_ax.vlines(np.mean(y_pred[y_true == c]), i - .5, i + .5, color='r')\n",
    "            self.graph_ax.vlines(.5, min(self._h_vals), max(self._h_vals), linewidth=.5)\n",
    "            self.graph_ax.hlines(self._h_vals, 0, 1, linewidth=.5)\n",
    "            self.graph_ax.set_xlim(0, 1)\n",
    "            self.graph_ax.set_ylim(min(self._h_vals), max(self._h_vals))\n",
    "            self.graph_ax.set_xticks(np.linspace(0, 1, 11))\n",
    "            self.graph_ax.set_yticks(self._classes)\n",
    "            self.graph_ax.set_yticklabels(self._cl_names)\n",
    "            self.graph_ax.set_xlabel('probability of true class', fontsize=12)\n",
    "            self.graph_ax.set_ylabel('true class', fontsize=12)\n",
    "            self.graph_ax.grid(axis='x', color='gainsboro', linewidth=.2)\n",
    "        else:\n",
    "            self.graph_ax.scatter(y_pred, y_true, lw=1, color=self.color,\n",
    "                                  edgecolor='black', alpha=self.alpha, linewidth=.5, s=self.size)\n",
    "            self.graph_ax.set_xlim(*x_bounds)\n",
    "            self.graph_ax.set_ylim(*y_bounds)\n",
    "            self.graph_ax.plot([*x_bounds], [*x_bounds], color='gainsboro')\n",
    "            self.graph_ax.set_xlabel('y_pred', fontsize=12)\n",
    "            self.graph_ax.set_ylabel('y_true', fontsize=12)\n",
    "            self.graph_ax.grid(color='gainsboro', linewidth=.2)\n",
    "        self.graph_ax.set_title(f'Prediction Dynamics \\nepoch: {self.epoch +1}/{self.n_epoch}')\n",
    "        self.df_out.update(pd.DataFrame(np.stack(self.learn.recorder.values)[-1].reshape(1,-1), \n",
    "                                        columns=self.learn.recorder.metric_names[1:-1], index=[self.epoch]))\n",
    "        self.graph_out.update(self.graph_ax.figure)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from fastai.data.all import *\n",
    "from fastai.metrics import *\n",
    "from tsai.data.all import *\n",
    "from tsai.models.utils import *\n",
    "from tsai.learner import *\n",
    "from tsai.models.InceptionTimePlus import *"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "X      - shape: [360 samples x 24 features x 51 timesteps]  type: memmap  dtype:float32  isnan: 0\n",
      "y      - shape: (360,)  type: memmap  dtype:<U3  n_classes: 6 (60 samples per class) ['1.0', '2.0', '3.0', '4.0', '5.0', '6.0']  isnan: False\n",
      "splits - n_splits: 2 shape: [180, 180]  overlap: [False]\n"
     ]
    }
   ],
   "source": [
    "dsid = 'NATOPS'\n",
    "X, y, splits = get_UCR_data(dsid, split_data=False)\n",
    "check_data(X, y, splits, False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: left;\">\n",
       "      <th>epoch</th>\n",
       "      <th>train_loss</th>\n",
       "      <th>valid_loss</th>\n",
       "      <th>accuracy</th>\n",
       "      <th>time</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <td>0</td>\n",
       "      <td>1.794817</td>\n",
       "      <td>1.674576</td>\n",
       "      <td>0.505556</td>\n",
       "      <td>00:05</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>1</td>\n",
       "      <td>1.287599</td>\n",
       "      <td>1.517164</td>\n",
       "      <td>0.672222</td>\n",
       "      <td>00:05</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>train_loss</th>\n",
       "      <th>valid_loss</th>\n",
       "      <th>accuracy</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>1.287599</td>\n",
       "      <td>1.517164</td>\n",
       "      <td>0.672222</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   train_loss  valid_loss  accuracy\n",
       "1    1.287599    1.517164  0.672222"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x432 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "tfms  = [None, [Categorize()]]\n",
    "batch_tfms = [TSStandardize(by_var=True)]\n",
    "dls = get_ts_dls(X, y, splits=splits, tfms=tfms, batch_tfms=batch_tfms)\n",
    "learn = ts_learner(dls, InceptionTimePlus, metrics=accuracy, cbs=PredictionDynamics()) \n",
    "learn.fit_one_cycle(2, 3e-3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/javascript": [
       "IPython.notebook.save_checkpoint();"
      ],
      "text/plain": [
       "<IPython.core.display.Javascript object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Converted 000_utils.ipynb.\n",
      "Converted 000b_data.validation.ipynb.\n",
      "Converted 000c_data.preparation.ipynb.\n",
      "Converted 001_data.external.ipynb.\n",
      "Converted 002_data.core.ipynb.\n",
      "Converted 003_data.preprocessing.ipynb.\n",
      "Converted 003b_data.transforms.ipynb.\n",
      "Converted 003c_data.mixed_augmentation.ipynb.\n",
      "Converted 003d_data.image.ipynb.\n",
      "Converted 003e_data.features.ipynb.\n",
      "Converted 005_data.tabular.ipynb.\n",
      "Converted 006_data.mixed.ipynb.\n",
      "Converted 007_metrics.ipynb.\n",
      "Converted 008_learner.ipynb.\n",
      "Converted 009_optimizer.ipynb.\n",
      "Converted 010_callback.core.ipynb.\n",
      "Converted 011_callback.noisy_student.ipynb.\n",
      "Converted 012_callback.gblend.ipynb.\n",
      "Converted 013_callback.TSBERT.ipynb.\n",
      "Converted 014_callback.PredictionDynamics.ipynb.\n",
      "Converted 100_models.layers.ipynb.\n",
      "Converted 100b_models.utils.ipynb.\n",
      "Converted 100c_models.explainability.ipynb.\n",
      "Converted 101_models.ResNet.ipynb.\n",
      "Converted 101b_models.ResNetPlus.ipynb.\n",
      "Converted 102_models.InceptionTime.ipynb.\n",
      "Converted 102b_models.InceptionTimePlus.ipynb.\n",
      "Converted 103_models.MLP.ipynb.\n",
      "Converted 103b_models.FCN.ipynb.\n",
      "Converted 103c_models.FCNPlus.ipynb.\n",
      "Converted 104_models.ResCNN.ipynb.\n",
      "Converted 105_models.RNN.ipynb.\n",
      "Converted 105_models.RNNPlus.ipynb.\n",
      "Converted 106_models.XceptionTime.ipynb.\n",
      "Converted 106b_models.XceptionTimePlus.ipynb.\n",
      "Converted 107_models.RNN_FCN.ipynb.\n",
      "Converted 107b_models.RNN_FCNPlus.ipynb.\n",
      "Converted 108_models.TransformerModel.ipynb.\n",
      "Converted 108b_models.TST.ipynb.\n",
      "Converted 108c_models.TSTPlus.ipynb.\n",
      "Converted 109_models.OmniScaleCNN.ipynb.\n",
      "Converted 110_models.mWDN.ipynb.\n",
      "Converted 111_models.ROCKET.ipynb.\n",
      "Converted 111b_models.MINIROCKET.ipynb.\n",
      "Converted 112_models.XResNet1d.ipynb.\n",
      "Converted 112b_models.XResNet1dPlus.ipynb.\n",
      "Converted 113_models.TCN.ipynb.\n",
      "Converted 114_models.XCM.ipynb.\n",
      "Converted 114b_models.XCMPlus.ipynb.\n",
      "Converted 120_models.TabModel.ipynb.\n",
      "Converted 130_models.MultiInputNet.ipynb.\n",
      "Converted 140_models.misc.ipynb.\n",
      "Converted 900_tutorials.ipynb.\n",
      "Converted index.ipynb.\n",
      "\n",
      "\n",
      "Checking folder: /Users/nacho/Documents/Machine_Learning/Jupyter_Notebooks/tsai/tsai\n",
      "Correct conversion! 😃\n",
      "Total time elapsed 167 s\n",
      "Thursday 11/02/21 19:22:34 CET\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "\n",
       "                <audio  controls=\"controls\" autoplay=\"autoplay\">\n",
       "                    <source src=\"data:audio/wav;base64,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\" type=\"audio/wav\" />\n",
       "                    Your browser does not support the audio element.\n",
       "                </audio>\n",
       "              "
      ],
      "text/plain": [
       "<IPython.lib.display.Audio object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# hide\n",
    "from tsai.imports import *\n",
    "out = create_scripts(); beep(out)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}
